Co je operátor „->“ v C ++?

-> není operátor. Ve skutečnosti jde o dva samostatné operátory - - a>.
Podmíněný kód dekrementuje x, zatímco vrací původní (ne dekrementovanou) hodnotu x a poté pomocí operátoru> porovná původní hodnotu s 0.
Pro lepší pochopení lze prohlášení napsat následovně:
while ((x--)> 0)
|
Nebo pro něco úplně jiného ... x sklouzne na 0.
while (x - \
\
\
\
> 0)
printf ("% d", x);
Ne tak matematické, ale ... každý obrázek vykreslí tisíc slov ...
|
To je velmi komplikovaný operátor, takže i ISO / IEC JTC1 (Společná technická komise 1) umístil jeho popis do dvou různých částí standardu C ++.
Pokud si děláme legraci, jsou to dva různé operátory: - a> popsané v §5.2.6 / 2 a §5.9 standardu C ++ 03.
|
Je to ekvivalent k
while (x--> 0)
x-- (post decrement) is equivalent to x = x-1 so, the code transforms to:
while (x> 0) {
x = x-1;
// logika
}
X--; // Snížení příspěvku provedeno, když x <= 0
|
x může jít na nulu ještě rychleji v opačném směru:
int x = 10;
while (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Rychlost můžete ovládat pomocí šipky!
int x = 100;
while (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Své
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x jde na 0
printf ("% d", x);
}
návrat 0;
}
Prostor dělá věci tak, aby vypadaly vtipně, - sníží a> porovná.
|
Použití -> má historický význam. Snižování bylo (a v některých případech stále je) rychlejší než zvyšování na architektuře x86. Použití -> naznačuje, že x bude na 0, a apeluje na ty, kteří mají matematické pozadí.
|
while (x--> 0)
je to tak analyzováno.
|
Naprosto geek, ale budu používat toto:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
do printf ("n je% d \ n", n) jako (n -> 0);
návrat 0;
}
|
Jedna kniha, kterou jsem četl (nepamatuji si správně, která kniha), uvedla: Překladače se pokoušejí analyzovat výrazy na největší token pomocí pravidla vlevo a vpravo.
V tomto případě výraz:
x -> 0
Analyzuje největší tokeny:
token 1: x
token 2: -
token 3:>
token 4: 0
uzavřít: x--> 0
Pro tento výraz platí stejné pravidlo:
a ----- b
Po analýze:
token 1: a
token 2: -
token 3: -
token 4: -
token 5: b
uzavřít: (a -) - - b
Doufám, že to pomůže pochopit složitý výraz ^ ^
|
To je přesně to samé jako
while (x--)
{
printf ("% d", x);
}
pro nezáporná čísla
|
Každopádně nyní máme operátor „jde do“. „->“ lze snadno zapamatovat jako směr a „zatímco x jde na nulu“ znamená přímý.
Navíc je na některých platformách o něco efektivnější než „for (x = 10; x> 0; x -)“.
|
Tento kód nejprve porovná x a 0 a poté sníží x. (Také řečeno v první odpovědi: Post-dekrementujete x a pak porovnáváte x a 0 s operátorem>.) Podívejte se na výstup tohoto kódu:
9 8 7 6 5 4 3 2 1 0
Nyní nejprve porovnáme a poté snížíme viděním 0 ve výstupu.
Pokud chceme nejprve dekrementovat a poté porovnat, použijte tento kód:
#include 
int main (neplatný)
{
int x = 10;
while (--x> 0) // x jde na 0
{
printf ("% d", x);
}
návrat 0;
}
Tento výstup je:
9 8 7 6 5 4 3 2 1
|
Můj kompilátor vytiskne 9876543210, když spustím tento kód.
#include 
int main ()
{
int x = 10;
while (x -> 0) // x jde na 0
{
std :: cout << x;
}
}
Podle očekávání. While (x--> 0) ve skutečnosti znamená while (x> 0). X-- zaúčtuje snížení x.
while (x> 0)
{
X--;
std :: cout << x;
}
je jiný způsob psaní stejné věci.
Je hezké, že originál vypadá jako „zatímco x jde na 0“.
|
Mezi - a> chybí mezera. x je post decremented, to znamená, decremented po kontrole podmínky x> 0?.
|
- je operátor dekrementace a> je operátor větší než.
Tyto dva operátory jsou použity jako jeden jako ->.
|
Je to kombinace dvou operátorů. Nejprve - slouží ke snížení hodnoty a> slouží ke kontrole, zda je hodnota větší než pravý operand.
#include 
int main ()
{
int x = 10;
while (x--> 0)
printf ("% d", x);
návrat 0;
}
Výstup bude:
9 8 7 6 5 4 3 2 1 0
|
Ve skutečnosti je x post-dekrementování a u této podmínky se kontroluje. Není to ->, je to (x--)> 0
Poznámka: hodnota x se po kontrole podmínky změní, protože se snižuje. Mohou také nastat některé podobné případy, například:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C a C ++ se řídí pravidlem „maximální práce“. Stejným způsobem je a --- b přeloženo do (a--) - b, ve vašem případě x -> 0 překládá do (x -)> 0.
Pravidlo v zásadě říká, že jde zleva doprava, výrazy se tvoří tak, že se vezme maximum znaků, které vytvoří platný výraz.
|
Proč všechny komplikace?
Jednoduchá odpověď na původní otázku je jen:
#include 
int main ()
{
int x = 10;
while (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Dělá totéž. Neříkám, že byste to měli dělat takto, ale dělá to samé a odpověděl by na otázku v jednom příspěvku.
X-- je pouze zkratka pro výše uvedené a> je jen normální operátor větší než. Žádné velké tajemství!
V dnešní době je příliš mnoho lidí, kteří si komplikují jednoduché věci;)
|
Konvenčním způsobem bychom definovali podmínku v závorkách while smyčky () a ukončovací podmínku uvnitř složených závorek {}, ale -> definuje obě najednou.
Například:
int abc (neplatné)
{
int a = 5
while ((a--)> 0) // Snížení a porovnání najednou
{
// Kód
}
}
Toto sníží a a spustí smyčku, zatímco a je větší než 0.
Obvykle by to bylo jako:
int abc (neplatné)
{
int a = 5;
while (a> 0)
{
A--;
// Kód
}
A--;
}
Oba způsoby děláme totéž a dosahujeme stejných cílů.
|
(x -> 0) znamená (x--> 0).
Můžete použít (x ->) Výstup: 9 8 7 6 5 4 3 2 1 0
Můžete použít (- x> 0) Je to průměr (--x> 0) Výstup: 9 8 7 6 5 4 3 2 1
Můžeš použít
(- \
\
x> 0)
Výstup: 9 8 7 6 5 4 3 2 1
Můžeš použít
(\
\
x -> 0)
Výstup: 9 8 7 6 5 4 3 2 1 0
Můžeš použít
(\
\
x -> 0
\
\
)
Výstup: 9 8 7 6 5 4 3 2 1 0
Můžete také použít
(
X
->
)
Výstup: 9 8 7 6 5 4 3 2 1 0
Podobně můžete vyzkoušet mnoho metod k úspěšnému provedení tohoto příkazu.
|
Tady - je unární operátor post dekrementace.
while (x--> 0) // x jde na 0
{
printf ("% d", x);
}
Na začátku bude podmínka vyhodnocena jako
(x> 0) // 10> 0
Nyní, protože podmínka je pravdivá, přejde do smyčky se sníženou hodnotou
x-- // x = 9
Proto je první tištěná hodnota 9
A tak dále. V poslední smyčce x = 1, takže podmínka je pravdivá. Podle unárního operátoru se hodnota v době tisku změnila na x = 0.
Nyní x = 0, které vyhodnotí podmínku (x> 0) jako false a smyčka while skončí.
|
Toto -> není vůbec operátor. Máme operátora jako ->, ale ne jako ->. Je to jen nesprávná interpretace while (x--> 0), což jednoduše znamená, že x má operátor post decrement a tato smyčka poběží, dokud nebude větší než nula.
Dalším jednoduchým způsobem psaní tohoto kódu by bylo while (x--). Smyčka while se zastaví, kdykoli dostane falešnou podmínku, a zde je pouze jeden případ, tj. 0. Takže se zastaví, když je hodnota x snížena na nulu.
|
Vysoce aktivní otázka. Získejte 10 reputace, abyste mohli odpovědět na tuto otázku. Požadavek na reputaci pomáhá chránit tuto otázku před spamem a neodpovědností.
Toto není odpověď, kterou hledáte? Projděte si další otázky se značkami operátorů jazyka C ++ C, které dodržují standardy formátování kódu, nebo si položte vlastní otázku.